import 'package:hive/hive.dart';
import '../models/task_model.dart';

/// 任务服务类
/// 封装所有与任务相关的Hive数据库操作
class TaskService {
  static const String _boxName = 'tasks';
  static Box<TaskModel>? _box;

  /// 初始化Hive Box
  static Future<void> init() async {
    _box = await Hive.openBox<TaskModel>(_boxName);

    // 如果是第一次使用，添加一些示例数据
    if (_box!.isEmpty) {
      await _addSampleData();
    }
  }

  /// 添加示例数据
  static Future<void> _addSampleData() async {
    final sampleTasks = [
      TaskModel(
        id: '1',
        title: '欢迎使用任务管理器！',
        description: '这是一个示例任务，帮助您快速上手。您可以编辑或删除它。',
        category: '通用',
        priority: 2,
        createdAt: DateTime.now(),
        tags: ['欢迎', '示例'],
      ),
      TaskModel(
        id: '2',
        title: '完成项目提案',
        description: '完成季度项目提案并提交给管理层审核。',
        category: '工作',
        priority: 3,
        createdAt: DateTime.now().subtract(const Duration(days: 1)),
        dueDate: DateTime.now().add(const Duration(days: 3)),
        tags: ['工作', '紧急'],
      ),
      TaskModel(
        id: '3',
        title: '购买生活用品',
        description: '购买牛奶、面包、鸡蛋和本周所需的蔬菜。',
        category: '购物',
        priority: 1,
        createdAt: DateTime.now().subtract(const Duration(hours: 2)),
        dueDate: DateTime.now().add(const Duration(days: 1)),
        tags: ['购物', '每周'],
      ),
      TaskModel(
        id: '4',
        title: '健身锻炼',
        description: '进行30分钟的有氧运动和力量训练。',
        category: '健康',
        priority: 2,
        createdAt: DateTime.now().subtract(const Duration(hours: 5)),
        tags: ['健康', '健身'],
      ),
      TaskModel(
        id: '5',
        title: '学习Flutter开发',
        description: '学习Flutter框架，掌握Riverpod状态管理和Hive数据库的使用。',
        category: '学习',
        priority: 2,
        createdAt: DateTime.now().subtract(const Duration(hours: 8)),
        dueDate: DateTime.now().add(const Duration(days: 7)),
        tags: ['学习', 'Flutter', '编程'],
      ),
    ];

    for (final task in sampleTasks) {
      await addTask(task);
    }
  }

  /// 获取Box实例
  static Box<TaskModel> get _taskBox {
    if (_box == null) {
      throw Exception('TaskService未初始化。请先调用TaskService.init()。');
    }
    return _box!;
  }

  /// 获取所有任务
  static List<TaskModel> getAllTasks() {
    return _taskBox.values.toList();
  }

  /// 根据ID获取任务
  static TaskModel? getTaskById(String id) {
    return _taskBox.values.firstWhere(
      (task) => task.id == id,
      orElse: () => throw StateError('Task not found'),
    );
  }

  /// 添加新任务
  static Future<void> addTask(TaskModel task) async {
    await _taskBox.put(task.id, task);
  }

  /// 更新任务
  static Future<void> updateTask(TaskModel task) async {
    await _taskBox.put(task.id, task);
  }

  /// 删除任务
  static Future<void> deleteTask(String id) async {
    await _taskBox.delete(id);
  }

  /// 删除所有任务
  static Future<void> deleteAllTasks() async {
    await _taskBox.clear();
  }

  /// 获取已完成的任务
  static List<TaskModel> getCompletedTasks() {
    return _taskBox.values.where((task) => task.isCompleted).toList();
  }

  /// 获取未完成的任务
  static List<TaskModel> getPendingTasks() {
    return _taskBox.values.where((task) => !task.isCompleted).toList();
  }

  /// 根据优先级获取任务
  static List<TaskModel> getTasksByPriority(int priority) {
    return _taskBox.values.where((task) => task.priority == priority).toList();
  }

  /// 根据分类获取任务
  static List<TaskModel> getTasksByCategory(String category) {
    return _taskBox.values.where((task) => task.category == category).toList();
  }

  /// 获取过期任务
  static List<TaskModel> getOverdueTasks() {
    return _taskBox.values.where((task) => task.isOverdue).toList();
  }

  /// 获取即将到期的任务
  static List<TaskModel> getDueSoonTasks() {
    return _taskBox.values.where((task) => task.isDueSoon).toList();
  }

  /// 搜索任务（根据标题和描述）
  static List<TaskModel> searchTasks(String query) {
    final lowerQuery = query.toLowerCase();
    return _taskBox.values.where((task) {
      return task.title.toLowerCase().contains(lowerQuery) ||
          task.description.toLowerCase().contains(lowerQuery) ||
          task.category.toLowerCase().contains(lowerQuery) ||
          task.tags.any((tag) => tag.toLowerCase().contains(lowerQuery));
    }).toList();
  }

  /// 获取所有分类
  static List<String> getAllCategories() {
    final categories = <String>{};
    for (final task in _taskBox.values) {
      categories.add(task.category);
    }
    return categories.toList()..sort();
  }

  /// 获取所有标签
  static List<String> getAllTags() {
    final tags = <String>{};
    for (final task in _taskBox.values) {
      tags.addAll(task.tags);
    }
    return tags.toList()..sort();
  }

  /// 获取任务统计信息
  static Map<String, int> getTaskStatistics() {
    final tasks = getAllTasks();
    return {
      'total': tasks.length,
      'completed': tasks.where((task) => task.isCompleted).length,
      'pending': tasks.where((task) => !task.isCompleted).length,
      'overdue': tasks.where((task) => task.isOverdue).length,
      'dueSoon': tasks.where((task) => task.isDueSoon).length,
      'highPriority': tasks.where((task) => task.priority == 3).length,
      'mediumPriority': tasks.where((task) => task.priority == 2).length,
      'lowPriority': tasks.where((task) => task.priority == 1).length,
    };
  }

  /// 批量操作：标记多个任务为完成
  static Future<void> markTasksAsCompleted(List<String> taskIds) async {
    for (final id in taskIds) {
      final task = getTaskById(id);
      if (task != null && !task.isCompleted) {
        await updateTask(task.markAsCompleted());
      }
    }
  }

  /// 批量操作：删除多个任务
  static Future<void> deleteTasks(List<String> taskIds) async {
    for (final id in taskIds) {
      await deleteTask(id);
    }
  }

  /// 导出任务数据为JSON
  static List<Map<String, dynamic>> exportTasks() {
    return getAllTasks().map((task) => task.toJson()).toList();
  }

  /// 从JSON导入任务数据
  static Future<void> importTasks(List<Map<String, dynamic>> tasksJson) async {
    for (final taskJson in tasksJson) {
      final task = TaskModel.fromJson(taskJson);
      await addTask(task);
    }
  }

  /// 清理过期的已完成任务（超过30天）
  static Future<int> cleanupOldCompletedTasks() async {
    final cutoffDate = DateTime.now().subtract(const Duration(days: 30));
    final tasksToDelete = _taskBox.values.where((task) {
      return task.isCompleted &&
          task.completedAt != null &&
          task.completedAt!.isBefore(cutoffDate);
    }).toList();

    for (final task in tasksToDelete) {
      await deleteTask(task.id);
    }

    return tasksToDelete.length;
  }

  /// 关闭Box
  static Future<void> close() async {
    await _box?.close();
    _box = null;
  }
}
